home *** CD-ROM | disk | FTP | other *** search
/ CU Amiga Super CD-ROM 15 / CU Amiga Magazine's Super CD-ROM 15 (1997)(EMAP Images)(GB)[!][issue 1997-10].iso / CUCD / Graphics / Ghostscript / source / gdevm8.c < prev    next >
C/C++ Source or Header  |  1996-10-29  |  7KB  |  221 lines
  1. /* Copyright (C) 1994, 1995, 1996 Aladdin Enterprises.  All rights reserved.
  2.   
  3.   This file is part of Aladdin Ghostscript.
  4.   
  5.   Aladdin Ghostscript is distributed with NO WARRANTY OF ANY KIND.  No author
  6.   or distributor accepts any responsibility for the consequences of using it,
  7.   or for whether it serves any particular purpose or works at all, unless he
  8.   or she says so in writing.  Refer to the Aladdin Ghostscript Free Public
  9.   License (the "License") for full details.
  10.   
  11.   Every copy of Aladdin Ghostscript must include a copy of the License,
  12.   normally in a plain ASCII text file named PUBLIC.  The License grants you
  13.   the right to copy, modify and redistribute Aladdin Ghostscript, but only
  14.   under certain conditions described in the License.  Among other things, the
  15.   License requires that the copyright notice and this notice be preserved on
  16.   all copies.
  17. */
  18.  
  19. /* gdevm8.c */
  20. /* 8-bit-per-pixel "memory" (stored bitmap) device */
  21. #include "memory_.h"
  22. #include "gx.h"
  23. #include "gxdevice.h"
  24. #include "gxdevmem.h"            /* semi-public definitions */
  25. #include "gdevmem.h"            /* private definitions */
  26.  
  27. /**************** NOTE: copy_rop only works for gray scale ****************/
  28. extern dev_proc_strip_copy_rop(mem_gray8_rgb24_strip_copy_rop);  /* in gdevmrop.c */
  29. #define mem_gray8_strip_copy_rop mem_gray8_rgb24_strip_copy_rop
  30.  
  31. /* ================ Standard (byte-oriented) device ================ */
  32.  
  33. #undef chunk
  34. #define chunk byte
  35.  
  36. /* Procedures */
  37. declare_mem_procs(mem_mapped8_copy_mono, mem_mapped8_copy_color, mem_mapped8_fill_rectangle);
  38.  
  39. /* The device descriptor. */
  40. const gx_device_memory far_data mem_mapped8_device =
  41.   mem_device("image8", 8, 0,
  42.     mem_mapped_map_rgb_color, mem_mapped_map_color_rgb,
  43.     mem_mapped8_copy_mono, mem_mapped8_copy_color, mem_mapped8_fill_rectangle,
  44.     mem_gray8_strip_copy_rop);
  45.  
  46. /* Convert x coordinate to byte offset in scan line. */
  47. #undef x_to_byte
  48. #define x_to_byte(x) (x)
  49.  
  50. /* Fill a rectangle with a color. */
  51. private int
  52. mem_mapped8_fill_rectangle(gx_device *dev,
  53.   int x, int y, int w, int h, gx_color_index color)
  54. {    fit_fill(dev, x, y, w, h);
  55.     bytes_fill_rectangle(scan_line_base(mdev, y) + x, mdev->raster,
  56.                  (byte)color, w, h);
  57.     return 0;
  58. }
  59.  
  60. /* Copy a monochrome bitmap. */
  61. /* We split up this procedure because of limitations in the bcc32 compiler. */
  62. private void mapped8_copy01(P9(chunk *, const byte *, int, int, uint,
  63.   int, int, byte, byte));
  64. private void mapped8_copyN1(P8(chunk *, const byte *, int, int, uint,
  65.   int, int, byte));
  66. private void mapped8_copy0N(P8(chunk *, const byte *, int, int, uint,
  67.   int, int, byte));
  68. private int
  69. mem_mapped8_copy_mono(gx_device *dev,
  70.   const byte *base, int sourcex, int sraster, gx_bitmap_id id,
  71.   int x, int y, int w, int h, gx_color_index zero, gx_color_index one)
  72. {    const byte *line;
  73.     int first_bit;
  74.     declare_scan_ptr(dest);
  75.     fit_copy(dev, base, sourcex, sraster, id, x, y, w, h);
  76.     setup_rect(dest);
  77.     line = base + (sourcex >> 3);
  78.     first_bit = 0x80 >> (sourcex & 7);
  79. #define is_color(c) ((int)(c) != (int)gx_no_color_index)
  80.     if ( is_color(one) )
  81.     {    if ( is_color(zero) )
  82.           mapped8_copy01(dest, line, first_bit, sraster, draster,
  83.                  w, h, (byte)zero, (byte)one);
  84.         else
  85.           mapped8_copyN1(dest, line, first_bit, sraster, draster,
  86.                  w, h, (byte)one);
  87.     }
  88.     else if ( is_color(zero) )
  89.       mapped8_copy0N(dest, line, first_bit, sraster, draster,
  90.              w, h, (byte)zero);
  91. #undef is_color
  92.     return 0;
  93. }
  94. /* Macros for copy loops */
  95. #define COPY_BEGIN\
  96.     while ( h-- > 0 )\
  97.     {    register byte *pptr = dest;\
  98.         const byte *sptr = line;\
  99.         register int sbyte = *sptr;\
  100.         register uint bit = first_bit;\
  101.         int count = w;\
  102.         do\
  103.         {
  104. #define COPY_END\
  105.             if ( (bit >>= 1) == 0 )\
  106.                 bit = 0x80, sbyte = *++sptr;\
  107.             pptr++;\
  108.         }\
  109.         while ( --count > 0 );\
  110.         line += sraster;\
  111.         inc_ptr(dest, draster);\
  112.     }
  113. /* Halftone coloring */
  114. private void
  115. mapped8_copy01(chunk *dest, const byte *line, int first_bit,
  116.   int sraster, uint draster, int w, int h, byte b0, byte b1)
  117. {    COPY_BEGIN
  118.     *pptr = (sbyte & bit ? b1 : b0);
  119.     COPY_END
  120. }
  121. /* Stenciling */
  122. private void
  123. mapped8_copyN1(chunk *dest, const byte *line, int first_bit,
  124.   int sraster, uint draster, int w, int h, byte b1)
  125. {    COPY_BEGIN
  126.     if ( sbyte & bit )
  127.       *pptr = b1;
  128.     COPY_END
  129. }
  130. /* Reverse stenciling */
  131. private void
  132. mapped8_copy0N(chunk *dest, const byte *line, int first_bit,
  133.   int sraster, uint draster, int w, int h, byte b0)
  134. {    COPY_BEGIN
  135.     if ( !(sbyte & bit) )
  136.       *pptr = b0;
  137.     COPY_END
  138. }
  139. #undef COPY_BEGIN
  140. #undef COPY_END
  141.  
  142. /* Copy a color bitmap. */
  143. private int
  144. mem_mapped8_copy_color(gx_device *dev,
  145.   const byte *base, int sourcex, int sraster, gx_bitmap_id id,
  146.   int x, int y, int w, int h)
  147. {    fit_copy(dev, base, sourcex, sraster, id, x, y, w, h);
  148.     mem_copy_byte_rect(mdev, base, sourcex, sraster, x, y, w, h);
  149.     return 0;
  150. }
  151.  
  152. /* ================ "Word"-oriented device ================ */
  153.  
  154. /* Note that on a big-endian machine, this is the same as the */
  155. /* standard byte-oriented-device. */
  156.  
  157. #if !arch_is_big_endian
  158.  
  159. /* Procedures */
  160. declare_mem_procs(mem8_word_copy_mono, mem8_word_copy_color, mem8_word_fill_rectangle);
  161.  
  162. /* Here is the device descriptor. */
  163. const gx_device_memory far_data mem_mapped8_word_device =
  164.   mem_full_device("image8w", 8, 0, mem_open,
  165.     mem_mapped_map_rgb_color, mem_mapped_map_color_rgb,
  166.     mem8_word_copy_mono, mem8_word_copy_color, mem8_word_fill_rectangle,
  167.     mem_word_get_bits, gx_default_map_cmyk_color,
  168.     gx_default_strip_tile_rectangle, gx_no_strip_copy_rop);
  169.  
  170. /* Fill a rectangle with a color. */
  171. private int
  172. mem8_word_fill_rectangle(gx_device *dev, int x, int y, int w, int h,
  173.   gx_color_index color)
  174. {    byte *base;
  175.     uint raster;
  176.     fit_fill(dev, x, y, w, h);
  177.     base = scan_line_base(mdev, y);
  178.     raster = mdev->raster;
  179.     mem_swap_byte_rect(base, raster, x << 3, w << 3, h, true);
  180.     bytes_fill_rectangle(base + x, raster, (byte)color, w, h);
  181.     mem_swap_byte_rect(base, raster, x << 3, w << 3, h, true);
  182.     return 0;
  183. }
  184.  
  185. /* Copy a bitmap. */
  186. private int
  187. mem8_word_copy_mono(gx_device *dev,
  188.   const byte *base, int sourcex, int sraster, gx_bitmap_id id,
  189.   int x, int y, int w, int h, gx_color_index zero, gx_color_index one)
  190. {    byte *row;
  191.     uint raster;
  192.     bool store;
  193.     fit_copy(dev, base, sourcex, sraster, id, x, y, w, h);
  194.     row = scan_line_base(mdev, y);
  195.     raster = mdev->raster;
  196.     store = (zero != gx_no_color_index && one != gx_no_color_index);
  197.     mem_swap_byte_rect(row, raster, x << 3, w << 3, h, store);
  198.     mem_mapped8_copy_mono(dev, base, sourcex, sraster, id,
  199.                   x, y, w, h, zero, one);
  200.     mem_swap_byte_rect(row, raster, x << 3, w << 3, h, false);
  201.     return 0;
  202. }
  203.  
  204. /* Copy a color bitmap. */
  205. private int
  206. mem8_word_copy_color(gx_device *dev,
  207.   const byte *base, int sourcex, int sraster, gx_bitmap_id id,
  208.   int x, int y, int w, int h)
  209. {    byte *row;
  210.     uint raster;
  211.     fit_copy(dev, base, sourcex, sraster, id, x, y, w, h);
  212.     row = scan_line_base(mdev, y);
  213.     raster = mdev->raster;
  214.     mem_swap_byte_rect(row, raster, x << 3, w << 3, h, true);
  215.     mem_copy_byte_rect(mdev, base, sourcex, sraster, x, y, w, h);
  216.     mem_swap_byte_rect(row, raster, x << 3, w << 3, h, false);
  217.     return 0;
  218. }
  219.  
  220. #endif                /* !arch_is_big_endian */
  221.